package com.bootdo.system.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.bootdo.common.config.BootdoConfig;
import com.bootdo.common.utils.*;
import com.bootdo.common.utils.httpUtils.UploadFile;
import com.bootdo.system.dao.FileAuditDao;
import com.bootdo.system.dao.FileInfoDao;
import com.bootdo.system.dao.SetDao;
import com.bootdo.system.dao.UserFileDao;
import com.bootdo.system.domain.*;
import com.bootdo.system.service.DeptService;
import com.bootdo.system.service.UserFileService;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.mime.HttpMultipartMode;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.util.EntityUtils;
import org.apache.shiro.util.CollectionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.PreparedStatementCreator;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.jdbc.support.GeneratedKeyHolder;
import org.springframework.jdbc.support.KeyHolder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;
import java.io.*;
import java.nio.charset.Charset;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
import java.util.*;

@Service
@Transactional
public class UserFileServiceImpl implements UserFileService {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @Autowired
    private UserFileDao userFileDao;

    @Autowired
    private FileInfoDao fileInfoDao;

    @Autowired
    private FileAuditDao fileAuditDao;

    @Autowired
    private SetDao setDao;

    @Autowired
    DeptService deptService;

    @Autowired
    private BootdoConfig bootdoConfig;

    /**
     * 获取文件列表信息
     * @param map
     * @return
     */
    @Override
    public List<UserFileDO> listFile(Map<String,Object> map) {
        List<UserFileDO> list = userFileDao.list(map);
        if(!CollectionUtils.isEmpty(list)) {
            for(UserFileDO data : list) {
                data.setFilesizeStr(UploadUtils.getFileSizePatter(data.getFilesize()));
            }
        }
        return list;
    }


    @Override
    public int countFile(Map<String, Object> map) {
        return userFileDao.count(map);
    }

    /**
     * 创建文件夹
     * @param userFileDO
     * @return
     */
    @Override
    public R createDir(UserFileDO userFileDO) {
        //获取文件保存根目录地址
        SetDO setDO = setDao.get("diskSave");
        if(null == setDO) {
            return R.error(1,"请设置磁盘文件保存根目录");
        }
        String rootPath = setDO.getSetValue();
        //获取上级目录地址
        Map<String,Object> map = new HashMap<String, Object>();
        map.put("userid",userFileDO.getUserid());
        //map.put("filename",userFileDO.getFilename());
        if(null != userFileDO.getBelong()) {
            map.put("belong",userFileDO.getBelong());
        }else {
            map.put("belong",-1);
        }
        UserFileDO userFileDO1 = userFileDao.getUserFileDetail(map);
        String virtualfilepath = "";
        if(null != userFileDO1 && StringUtils.isNotEmpty(userFileDO1.getVirtualfilepath())) {
            virtualfilepath = userFileDO1.getVirtualfilepath() +  File.separator + userFileDO.getFilename();
            //return R.error(1,"当前文件目录已存在");
        }else {
            virtualfilepath = rootPath + File.separator + userFileDO.getUsername() + File.separator + userFileDO.getFilename();
        }
        map = new HashMap<String, Object>();
        map.put("virtualfilepath",virtualfilepath);
        UserFileDO userFileDO2 = userFileDao.getUserFileDetail(map);
        if(null != userFileDO2) {
            return R.error(1,"当前文件目录已存在");
        }
        //目录创建成功，保存记录到user_file表中
        //ip地址
        // 获取request
        HttpServletRequest request = HttpContextUtils.getHttpServletRequest();
        userFileDO.setIp(IPUtils.getIpAddr(request));
        //是否目录（0.否   1.是）
        userFileDO.setIsFolder(1);
        userFileDO.setVirtualfilepath(virtualfilepath);
        userFileDO.setAddtime(new Date());
        userFileDO.setIsreceive(0);
        userFileDao.save(userFileDO);
        //创建目录
        /*File dir = new File(virtualfilepath);
        if(!dir.exists()) {
            dir.mkdirs();
        }*/
        return R.ok();
    }

    /**
     * 文件上传
     * @param files
     * @param userFileDO
     * @return
     */
    @Override
    public R uploadFile(MultipartFile[] files, UserFileDO userFileDO) {
        //获取文件保存根目录地址
        SetDO setDO = setDao.get("diskSave");
        if(null == setDO) {
            return R.error(1,"请设置磁盘文件保存根目录");
        }
        String rootPath = setDO.getSetValue();
        //获取上级目录地址
        Map<String,Object> map = new HashMap<String, Object>();
        map.put("userid",userFileDO.getUserid());
        if(null != userFileDO.getBelong()) {
            map.put("belong",userFileDO.getBelong());
        }else {
            map.put("belong",-1);
        }
        UserFileDO userFileDO1 = userFileDao.getUserFileDetail(map);
        //虚拟上传目录
        String uploadPath = "";
        if(null != userFileDO1 && StringUtils.isNotEmpty(userFileDO1.getVirtualfilepath())) {
            uploadPath = userFileDO1.getVirtualfilepath();
        }else {
            uploadPath = rootPath + File.separator + userFileDO.getUsername();
        }
        //实际文件存储路径
        String actualPath = rootPath;
        if(files != null && files.length > 0){
            //循环获取file数组中得文件
            for(int i = 0;i < files.length;i++){
                MultipartFile file = files[i];
                //保存文件
                if (!file.isEmpty()){
                    // 生成文件上传路径，先对该路径是否存在进行判断
                    /*String folder = rootPath;
                    File floder = new File(folder);
                    if (!floder.exists()) {
                        try {
                            floder.mkdirs();
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }*/
                    try {
                        //获取文件名称
                        String fileName = file.getOriginalFilename();
                        // 获取文件的后缀名
                        String fileType = fileName.substring(fileName.lastIndexOf("."));
                        fileType = fileType.substring(1,fileType.length());
                        // 将获取到的附件file,transferTo写入到指定的位置(即:创建dest时，指定的路径)
                        String filePath = uploadPath + File.separator +fileName;
                        actualPath = actualPath + File.separator +fileName;
                        //文件MD5值
                        String filemd5 = "";
                        try{
                            filemd5 = MD5Utils.encrypt(actualPath);
                        }catch (Exception e) {
                            //异常表示文件之前没有上传
                            filemd5 = "-1";
                        }
                        //根据文件MD5值判断文件是否已经上传,如果已经上传，则不需要进行文件流上传，只需要保存到user_file表中
                        Map<String,Object> map1 = new HashMap<String, Object>();
                        map1.put("filemd5",filemd5);
                        FileInfoDO fileInfoDO1 = fileInfoDao.getFileInfoDetail(map1);
                        if(null == fileInfoDO1) {

                            //文件流上传(临时文件)
                            //file.transferTo(new File(filePath));
                            try  {
                                //获得文件上传的流
                                InputStream inputStream = file.getInputStream();
                                //创建一个文件输出流
                                FileOutputStream fos = new FileOutputStream(File.separator + actualPath);
                                //创建一个缓冲区
                                byte[] buffer = new byte[1024 * 1024];
                                //判断是否读取完毕
                                int len = 0;
                                //如果大于0说明还存在数据;
                                while ((len = inputStream.read(buffer)) > 0) {
                                    fos.write(buffer, 0, len);
                                    fos.flush();
                                }
                                //关闭流
                                fos.close();
                                inputStream.close();

                            }  catch  (FileNotFoundException e) {
                                e.printStackTrace();
                            }


                            /** 0:文件已经正常上传
                             * -1：文件类型错误
                             *  1：文件正在进行类型检查
                             * -2：文件存在病毒
                             *  2：文件正在杀毒
                             * -3：文件加密失败
                             *  3：文件正在进行加密*/
                            int count = UploadFile.uploadFile(new File(actualPath),userFileDO.getFileuuid());

                            //保存到文件基础表数据库
                            FileInfoDO fileInfoDO = new FileInfoDO();
                            fileInfoDO.setUuid(UuidUtils.getUUID());
                            fileInfoDO.setFilename(fileName.substring(0, fileName.lastIndexOf(".")));
                            fileInfoDO.setFiletype(fileType);
                            fileInfoDO.setFilesize(file.getSize());
                            fileInfoDO.setAddtime(new Date());
                            //文件md5值
                            fileInfoDO.setFilemd5(MD5Utils.encrypt(actualPath));
                            //是否成功发送到对方(0.否  1.是)
                            fileInfoDO.setStatus(String.valueOf(count));
                            fileInfoDao.save(fileInfoDO);

                            //java定时器（文件上传成功之后30s同步到另一台服务器）
                            if(count != 0) {
                                //加密成功才可以同步文件
                                boolean flag = false;
                                try {
                                    flag = synchroServer(rootPath,actualPath,file.getOriginalFilename(), fileInfoDO);
                                } catch (Exception e) {
                                    e.printStackTrace();
                                }
                                if(flag) {
                                    //发送成功
                                    fileInfoDO.setStatus("1");
                                    fileInfoDao.update(fileInfoDO);
                                }
                            }

                            userFileDO.setFileuuid(fileInfoDO.getUuid());
                        }else {
                            userFileDO.setFileuuid(fileInfoDO1.getUuid());
                        }
                        //保存记录到user_file表中
                        //ip地址
                        // 获取request
                        HttpServletRequest request = HttpContextUtils.getHttpServletRequest();
                        userFileDO.setIp(IPUtils.getIpAddr(request));
                        userFileDO.setFilename(fileName.substring(0, fileName.lastIndexOf(".")));
                        userFileDO.setFiletype(fileType);
                        //是否目录（0.否   1.是）
                        userFileDO.setIsFolder(0);
                        //状态（-1：类型检查，-2：病毒扫描，-3：加密失败，1：上传成功）
                        userFileDO.setStatus(1);
                        userFileDO.setVirtualfilepath(filePath);
                        userFileDO.setAddtime(new Date());
                        //是否是接收文件（0:否，1：是）
                        userFileDO.setIsreceive(0);
                        userFileDao.save(userFileDO);

                    } catch (IllegalStateException e) {
                        e.printStackTrace();
                    } catch (IOException e) {
                        e.printStackTrace();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }
        R r = new R();
        r.put("code","200");
        return r;
    }

    /**
     * 文件同步到另一台服务器
     * @param rootPath
     * @param actualPath
     * @param file
     * @return
     */
    @Override
    public R synchroFile(String rootPath, String actualPath, MultipartFile file, String fileId, String uuid,String fileName, String fileType) {
        //文件流上传
       /* Map<String,Object> map = new HashMap<String, Object>();
        map.put("uuid",uuid);
        FileInfoDO fileInfoDO1 = fileInfoDao.getFileInfoDetail(map);*/
        try  {
            //获取输出流
            OutputStream os= new FileOutputStream(actualPath);
            //获取输入流 CommonsMultipartFile 中可以直接得到文件的流
            InputStream is = file.getInputStream();
            //读取数据
            //一次性取多少字节
            byte[] bytes = new byte[1024];
            //接受读取的内容(n就代表的相关数据，只不过是数字的形式)
            int n = -1;
            //循环取出数据
            while ((n = is.read(bytes,0,bytes.length)) != -1) {
                //写入相关文件
                os.write(bytes, 0, n);
            }
            os.flush();
            os.close();
            is.close();
        }  catch  (FileNotFoundException e) {
            e.printStackTrace();
            return R.error();
        } catch (IOException e) {
            e.printStackTrace();
        }
        //正常同步成功
        /*FileInfoDO fileInfoDO = new FileInfoDO();
        fileInfoDO.setId(fileInfoDO1.getId());
        //同步时间
        fileInfoDO.setAsynctime(new Date());
        fileInfoDO.setStatus("1");
        fileInfoDao.update(fileInfoDO);*/
        return R.ok();
    }

    /**
     * 文件发送
     * @param fileAuditDO
     * @return
     */
    @Override
    public R batchSend(FileAuditDO fileAuditDO) {
        R r= new R();
        List<String> ids = Arrays.asList(fileAuditDO.getIds().split(","));
        if(null != ids && ids.size() > 0) {
            for(String id : ids) {

                //获取是否启用禁止发送文件类型(0：关闭 1：打开)
                SetDO setDO1 = setDao.get("forbidFileType");
                if(null != setDO1 && StringUtils.isEmpty(setDO1.getSetValue())) {
                    return R.error(1,"请设置是否启用禁止发送文件类型");
                }
                //获取禁止发送文件类型
                List<SetDO> list1 = new ArrayList<SetDO>();
                if(StringUtils.equals("1",setDO1.getSetValue())) {
                    //开启
                    list1 = setDao.list("forbidType");
                }

                //获取是否启用禁止发送文件关键字(0：关闭 1：打开)
                SetDO setDO2 = setDao.get("forbidKeyword");
                if(null != setDO2 && StringUtils.isEmpty(setDO2.getSetValue())) {
                    return R.error(1,"请设置是否启用禁止发送文件关键字");
                }
                //获取禁止发送文件关键字
                List<SetDO> list2 = new ArrayList<SetDO>();
                if(StringUtils.equals("1",setDO2.getSetValue())) {
                    //开启
                    list2 = setDao.list("Keyword");
                }

                //根据fileUser表中的id查询uuid
                UserFileDO userFileDO = userFileDao.get(Integer.parseInt(id));
                //是否能够发送文件标识
                boolean flag1 = true;

                if(StringUtils.equals("1",setDO1.getSetValue())) {
                    //启用禁止发送文件类型
                    //遍历禁止发送文件类型
                    if(!CollectionUtils.isEmpty(list1)) {
                        for(SetDO data : list1) {
                            if(!flag1) {
                                break;
                            }
                            if(StringUtils.equals(userFileDO.getFiletype(),data.getSetValue())) {
                                flag1 = false;
                            }else {
                                if(StringUtils.equals("1",setDO2.getSetValue())) {
                                    //启用禁止发送文件关键字
                                    //遍历禁止发送文件关键字
                                    if(!CollectionUtils.isEmpty(list2)) {
                                        for(SetDO data1 : list2) {
                                            if(userFileDO.getFilename().contains(data1.getSetValue())) {
                                                flag1 = false;
                                            }
                                            break;
                                        }
                                    }
                                    if(!flag1) {
                                        break;
                                    }
                                }
                            }
                            break;
                        }
                    }
                }
                if(flag1) {
                    //是否需要审批标识(启用，生成审批记录，不启用，直接生成用户文件记录)
                    boolean flag2 = true;
                    //获取是否启用文件审批(0：关闭 1：打开)
                    SetDO setDO3 = setDao.get("enableFileAuidtOn");
                    if(null != setDO3 && StringUtils.isEmpty(setDO3.getSetValue())) {
                        return R.error(1,"请设置是否启用文件审批");
                    }
                    if(StringUtils.equals("1",setDO3.getSetValue())) {
                        //启用
                        //获取是否启用文件类型免审批(0：关闭 1：打开)
                        SetDO setDO4 = setDao.get("noAuidtTypeOn");
                        if(null != setDO4 && StringUtils.isEmpty(setDO4.getSetValue())) {
                            return R.error(1,"请设置是否启用文件类型免审批");
                        }
                        if(StringUtils.equals("1",setDO4.getSetValue())) {
                            //启用
                            //获取文件免审批文件类型
                            List<SetDO> list3 = setDao.list("noAuidtFile");
                            if(!CollectionUtils.isEmpty(list3)) {
                                for(SetDO data : list3) {
                                    if(StringUtils.equals(userFileDO.getFiletype(),data.getSetValue())) {
                                        flag2 = false;
                                    }
                                    if(!flag2) {
                                        break;
                                    }
                                }
                            }
                        }
                    }else {
                        flag2 = false;
                    }

                    //根据uuid查询fileInfo表中的id
                    /*Map<String, Object> map = new HashMap<String, Object>();
                    map.put("uuid",userFileDO.getFileuuid());
                    FileInfoDO fileInfoDO = fileInfoDao.getFileInfoDetail(map);*/

                    fileAuditDO.setFileid(userFileDO.getId());
                    fileAuditDO.setSendtime(new Date());
                    if(flag2) {
                        //需要审批，新增审批记录
                        //审批结果（0:等待审批  1:审批通过   2:拒绝通过 3:免审批）
                        //遍历接收人
                        List<String> targetIdList = Arrays.asList(fileAuditDO.getTargetIds().split(","));
                        if(!CollectionUtils.isEmpty(targetIdList)) {
                            for(String targetId : targetIdList) {
                                fileAuditDO.setTargetid(Integer.parseInt(targetId));
                                fileAuditDO.setAuditstate("0");
                                fileAuditDO.setSzflag("0");//有效
                                fileAuditDao.save(fileAuditDO);
                            }
                        }
                    }else {
                        //直接免审批（3:免审批）新增审批记录与接收记录
                        //审批结果（0:等待审批  1:审批通过   2:拒绝通过 3:免审批）
                        //遍历接收人
                        List<String> targetIdList = Arrays.asList(fileAuditDO.getTargetIds().split(","));
                        if(!CollectionUtils.isEmpty(targetIdList)) {
                            for(String targetId : targetIdList) {
                                fileAuditDO.setTargetid(Integer.parseInt(targetId));
                                fileAuditDO.setAuditstate("3");
                                fileAuditDO.setSzflag("0");//有效
                                fileAuditDao.save(fileAuditDO);

                                //新增人即为接收人
                                userFileDO.setUserid(Long.valueOf(targetId));
                                userFileDO.setAddtime(new Date());
                                //是否是接收文件（0:否，1：是）
                                userFileDO.setIsreceive(1);
                                userFileDao.save(userFileDO);
                            }
                        }
                    }
                }
            }
        }
        return r;
    }

    /**
     * 判断文件是否可以发送
     * @param ids
     * @return
     */
    @Override
    public R judeSend(Integer[] ids) {
        R r= new R();
        if(null != ids && ids.length > 0) {

            //获取是否启用禁止发送文件类型(0：关闭 1：打开)
            SetDO setDO1 = setDao.get("forbidFileType");
            if(null != setDO1 && StringUtils.isEmpty(setDO1.getSetValue())) {
                return R.error(1,"请设置是否启用禁止发送文件类型");
            }
            //获取禁止发送文件类型
            List<SetDO> list1 = new ArrayList<SetDO>();
            if(StringUtils.equals("1",setDO1.getSetValue())) {
                //开启
                list1 = setDao.list("forbidType");
            }

            //获取是否启用禁止发送文件关键字(0：关闭 1：打开)
            SetDO setDO2 = setDao.get("forbidKeyword");
            if(null != setDO2 && StringUtils.isEmpty(setDO2.getSetValue())) {
                return R.error(1,"请设置是否启用禁止发送文件关键字");
            }
            //获取禁止发送文件关键字
            List<SetDO> list2 = new ArrayList<SetDO>();
            if(StringUtils.equals("1",setDO2.getSetValue())) {
                //开启
                list2 = setDao.list("Keyword");
            }

            for(Integer id : ids) {
                //根据fileUser表中的id查询uuid
                UserFileDO userFileDO = userFileDao.get(id);

                //判断文件是是否是病毒文件（-1：类型检查失败，-2：存在病毒，-3：加密失败，0：上传成功）
                if(userFileDO.getStatus() == -2) {
                    return R.error(1,"文件名为" + userFileDO.getFilename() + "的文件存在病毒，不可发送");
                }

                if(StringUtils.equals("1",setDO1.getSetValue())) {
                    //启用禁止发送文件类型
                    //遍历禁止发送文件类型
                    if(!CollectionUtils.isEmpty(list1)) {
                        for(SetDO data : list1) {
                            if(StringUtils.equals(userFileDO.getFiletype(),data.getSetValue())) {
                                return R.error(1,"文件类型为" + data.getSetValue() + "的文件被禁止发送");
                            }
                        }
                    }
                }
                if(StringUtils.equals("1",setDO2.getSetValue())) {
                    //启用禁止发送文件关键字
                    //遍历禁止发送文件关键字
                    if(!CollectionUtils.isEmpty(list2)) {
                        for(SetDO data : list2) {
                            if(userFileDO.getFilename().contains(data.getSetValue())) {
                                return R.error(1,"文件名包含" + data.getSetValue() + "关键字的文件被禁止发送");
                            }
                        }
                    }
                }
            }
        }
        return r;
    }

    /**
     * 获取我收到的文件列表信息
     * @param map
     * @return
     */
    @Override
    public List<UserFileDO> getMyReceiveFileList(Map<String, Object> map) {
        List<UserFileDO> list = userFileDao.list(map);
        if(!CollectionUtils.isEmpty(list)) {
            for(UserFileDO data : list) {
                data.setFilesizeStr(UploadUtils.getFileSizePatter(data.getFilesize()));
            }
        }
        return list;
    }

    @Override
    public int count(Map<String, Object> map) {
        return userFileDao.count(map);
    }

    @Override
    public UserFileDO getDetail(int belong) {
        UserFileDO userFileDO = userFileDao.get(belong);
        if(null != userFileDO) {
            userFileDO.setFilesizeStr(UploadUtils.getFileSizePatter(userFileDO.getFilesize()));
        }
        return userFileDO;
    }

    /**
     * 删除文件及文件夹
     * @param ids
     * @return
     */
    @Override
    public R deleteFile(Integer[] ids) {
        if(null != ids && ids.length > 0) { //获取文件保存根目录地址
            UserFileDO userFileDO = null;
            Map<String,Object> map = null;
            //获取文件保存根目录地址
            SetDO setDO = setDao.get("diskSave");
            if(null == setDO) {
                return R.error(1,"请设置磁盘文件保存根目录");
            }
            String rootPath = setDO.getSetValue();
            for(Integer id : ids) {
                userFileDO = new UserFileDO();
                //根据文件id获取文件(夹)名称
                userFileDO = userFileDao.get(id);
                if(null != userFileDO) {
                    if( 1 == userFileDO.getIsFolder() ) {
                        //文件夹直接删除
                        userFileDao.remove(id);
                    }else {
                        //文件删除
                        map = new HashMap<String, Object>();
                        map.put("fileuuid",userFileDO.getFileuuid());
                        int count = userFileDao.count(map);
                        if(count == 1) {
                            //只剩最后一个文件，删除file_info表中数据，删除本地磁盘数据
                            //删除user_file表中数据
                            userFileDao.remove(id);
                            //删除file_info表中数据
                            fileInfoDao.removeByUuid(userFileDO.getFileuuid());
                            //删除本地磁盘数据
                            System.gc();
                            String actualPath = rootPath + File.separator + userFileDO.getFilename() + "." + userFileDO.getFiletype();
                            File file = new File(actualPath);
                            file.delete();
                            //删除本地磁盘加密数据
                            String actualPathEncry = rootPath + File.separator + "ENCRY_" + userFileDO.getFileuuid() + userFileDO.getFilename() + "." + userFileDO.getFiletype();
                            File file1 = new File(actualPathEncry);
                            file1.delete();
                            //文件所属文件夹路径
                            String filePath = rootPath + File.separator + userFileDO.getFilename();
                            //删除分段文件及总文件夹
                            deleteDir(filePath);
                            deleteDir(filePath);
                        }else {
                            //删除user_file表中数据
                            userFileDao.remove(id);
                        }
                    }
                }
            }
        }
        return R.ok();
    }

    /**
     * 判断文件是否可以删除（文件夹下有文件不可删除）
     * @param ids
     * @return
     */
    @Override
    public R judeDeleteFile(Integer[] ids) {
        if(null != ids && ids.length > 0) {
            Map<String,Object> map = null;
            for(Integer id : ids) {
                map = new HashMap<String, Object>();
                map.put("belong",id);
                map.put("isFolder","0");//文件
                int count = userFileDao.count(map);
                if(count > 0) {
                    //表示该文件夹下有文件信息
                    //根据文件id获取文件夹名称
                    UserFileDO userFileDO = userFileDao.get(id);
                    return R.error(1,"文件夹名称为" + userFileDO.getFilename() + "的文件夹下存在文件，不可删除");
                }
            }
        }
        return R.ok();
    }

    /**
     * 检查审批
     *
     * @param path
     * @return
     */
    public int checkFile(String path) {
        /*File file = new File(path);
        map = sendDao.selectSwitch();
        list = sendDao.checkFile();
        System.out.printf("数组值：" + list);
        if ("1".equals(map.get("enableFileAuidtOn"))) {
            return 1;//文件需要审批
        } else if ("1".equals(map.get("noAuidtTypeOn"))) {
            for (SystemsetEntity value : list) {
                if ((file.getName().substring(file.getName().lastIndexOf("1") + 1)).equals(value.getSetvalue())) {
                    return -1;//是一个免审批文件
                } else
                    return 1;//文件需要审批
            }
        } else {
            return 0;//文件不需要审批
        }
        if ("1".equals(map.get("forbidFileTypeOn"))) {
            for (SystemsetEntity value : list) {
                if ((file.getName().substring(file.getName().lastIndexOf("1") + 1)).equals(value.getSetvalue())) {
                    return -2;//是一个禁止发送文件
                } else
                    return 0;//正常发送
            }
        }
        if ("1".equals(map.get("forbidKeywordOn"))) {
            for (SystemsetEntity value : list) {
                if ((file.getName().substring(file.getName().lastIndexOf("1") + 1)).equals(value.getSetvalue())) {
                    return -3;//是一个关键字禁止发送文件
                } else
                    return 0;//正常发送
            }
        }*/
        return 0;
    }

    /**
     * 文件同步到另一台服务器
     * @return
     */
    private boolean synchroServer(String rootPath, String encryPath, String originalFilename, FileInfoDO fileInfoDO) throws Exception {
        //查询文件是否已经同步到对方服务器
        final boolean[] flag = {false};
        //获取配置文件地址
        String synchroPath = bootdoConfig.getSynchroPath();
        //读取配置文件里面的文件信息
        Properties properties = new Properties();
        // 使用InPutStream流读取properties文件
        BufferedReader bufferedReader = null;
        try {
            bufferedReader = new BufferedReader(new FileReader(synchroPath));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        try {
            properties.load(bufferedReader);
        } catch (IOException e) {
            e.printStackTrace();
        }
        //获取同步服务器ip地址
        String synchroIp = properties.getProperty("synchroIp");
        //获取同步服务器port端口号
        String synchroPort = properties.getProperty("synchroPort");
        //获取同步服务器相隔时间time
        String synchroTime = properties.getProperty("synchroTime");
        if(StringUtils.isNotEmpty(synchroIp) && StringUtils.isNotEmpty(synchroPort)) {
            //同步服务器访问地址
            String ipPath = "https://" + synchroIp + ":" + synchroPort + "/sys/userFile/synchroFile";
            File newFile = new File(encryPath);
            InputStream inputStream = new FileInputStream(newFile);

            String logData = "";
            SimpleDateFormat sdf =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss" );
            Date d= new Date();
            String str = sdf.format(d);
            String logPath = bootdoConfig.getLogPath();
            String logLocation = bootdoConfig.getLogLocation();
            logData = "------文件开始同步;开始时间为" + str + "--------";
            //文件同步日志记录
            FileUtil.writeFile(logData, logPath, logLocation);

            Timer timer = new Timer();
            timer.schedule(new TimerTask() {
                public void run() {
                    final boolean[] flag = {false};
                    String content = "";
                    CloseableHttpClient httpClient = null;
                    try {
                        httpClient = new SslUtils();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    HttpPost httpPost = new HttpPost(ipPath);
                    MultipartEntityBuilder builder = MultipartEntityBuilder.create();
                    builder.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);//解决返回中文乱码问题
                    builder.setCharset(Charset.forName("UTF-8")); //此处踩坑，转发出去的filename依然为乱码
                    ContentType strContent = ContentType.create("text/plain",Charset.forName("UTF-8"));
                    builder.addTextBody("rootPath", rootPath,strContent);
                    builder.addTextBody("actualPath", encryPath,strContent);
                    builder.addTextBody("fileId",fileInfoDO.getId().toString(),strContent);
                    builder.addTextBody("uuid",fileInfoDO.getUuid(),strContent);
                    builder.addTextBody("fileName",fileInfoDO.getFilename(),strContent);
                    builder.addTextBody("fileType",fileInfoDO.getFiletype(),strContent);
                    try {
                        builder.addBinaryBody("file", inputStream, ContentType.MULTIPART_FORM_DATA, originalFilename);
                        HttpEntity httpEntity = builder.build();
                        httpPost.setEntity(httpEntity);
                        HttpResponse httpResponse = httpClient.execute(httpPost);
                        HttpEntity responseEntity = httpResponse.getEntity();
                        if(null != responseEntity) {
                            content = EntityUtils.toString(responseEntity, "UTF-8");
                        }
                    }catch (IOException e) {
                        e.printStackTrace();
                    }finally {
                        try {
                            httpClient.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                    String logData1 = "";
                    JSONObject jsonObject = JSON.parseObject(content);
                    Date d1 = new Date();
                    String str1 = sdf.format(d1);
                    if(null != jsonObject) {
                        String code = jsonObject.getString("code");
                        if(StringUtils.equals("0",code)) {
                            flag[0] = true;
                            logData1 = "------文件同步成功;同步时间为" + str1 + ";服务器的ip为" + synchroIp + ";端口号为" + synchroPort +
                                    ";请求url为" + ipPath + ";文件名为" + fileInfoDO.getFilename() + "." + fileInfoDO.getFiletype() + "--------";
                        }
                    }else {
                        flag[0] = false;
                        logData1 = "------文件同步失败;同步时间为" + str1 + ";服务器的ip为" + synchroIp + ";端口号为" + synchroPort +
                                ";请求url为" + ipPath + ";文件名为" + fileInfoDO.getFilename() + "." + fileInfoDO.getFiletype() + "--------";
                        //文件同步到另一个数据库中
                        //获取同步服务器ip地址
                        DriverManagerDataSource dataSource=new DriverManagerDataSource();
                        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
                        dataSource.setUrl("jdbc:mysql://localhost:" + bootdoConfig.getRemoteDataBasePort() + "/baidujiex");
                        dataSource.setUsername(bootdoConfig.getRemoteDataBaseUser());
                        dataSource.setPassword(bootdoConfig.getRemoteDataBasePassword());
                        JdbcTemplate jdbcTemplate=new JdbcTemplate(dataSource);
                        String sql = "insert into baidujiex.file_info(id,uuid,filename,filetype,filemd5) values(null,?,?,?,?)";
                        KeyHolder keyHolder = new GeneratedKeyHolder();
                        jdbcTemplate.update(new PreparedStatementCreator() {
                            @Override
                            public PreparedStatement createPreparedStatement(Connection connection) throws SQLException {
                                PreparedStatement ps = connection.prepareStatement(sql,new String[]{"id"});
                                ps.setString(1,fileInfoDO.getUuid());
                                ps.setString(2,fileInfoDO.getFilename());
                                ps.setString(3,fileInfoDO.getFiletype());
                                ps.setString(4,fileInfoDO.getFilemd5());
                                return ps;
                            }
                        },keyHolder);
                    }
                    //文件同步日志记录
                    FileUtil.writeFile(logData1, logPath, logLocation);
                    timer.cancel();
                }
            }, Integer.parseInt(synchroTime) * 1000);
        }
        return flag[0];
    }


    @Override
    public List<ReportDo> reportList(Map<String, Object> map){
        String deptId = map.get("deptId").toString();
        if (StringUtils.isNotBlank(deptId)) {
            Long deptIdl = Long.valueOf(deptId);
            List<Long> childIds = deptService.listChildrenIds(deptIdl);
            childIds.add(deptIdl);
            map.put("deptId", null);
            map.put("deptIds",childIds);
        }
        return userFileDao.reportList(map);
    }


    @Override
    public int reportCount(Map<String, Object> map){
        String deptId = map.get("deptId").toString();
        if (StringUtils.isNotBlank(deptId)) {
            Long deptIdl = Long.valueOf(deptId);
            List<Long> childIds = deptService.listChildrenIds(deptIdl);
            childIds.add(deptIdl);
            map.put("deptId", null);
            map.put("deptIds",childIds);
        }
        return userFileDao.reportCount(map);
    }

    @Override
    public List<UserFileDO> getMyReceiveFileListFor(Map<String, Object> map) {
        List<UserFileDO> list = userFileDao.getMyReceiveFileListFor(map);
        if(!CollectionUtils.isEmpty(list)) {
            for(UserFileDO data : list) {
                data.setFilesizeStr(UploadUtils.getFileSizePatter(data.getFilesize()));
            }
        }
        return list;
    }

    @Override
    public int countFor(Map<String, Object> map) {
        return userFileDao.countFor(map);
    }

    @Override
    public List<ReportDo> tenReportList(Map<String, Object> map){
        return userFileDao.tenReportList(map);
    }

    @Override
    public int tenReportCount(Map<String, Object> map){
        return userFileDao.tenReportCount(map);
    }

    @Override
    public ReportDo tenReportByTime(String addtime){
        return userFileDao.tenReportByTime(addtime);
    }


    @Override
    public List<ReportDo> typeList(Map<String, Object> map){
        return userFileDao.typeList(map);
    }


    @Override
    public  int typeCount(Map<String, Object> map){
        return userFileDao.typeCount(map);
    }

    /**
     * 关系递归
     * @param userFileDO
     * @return
     */
    @Override
    public List<UserFileDO> listFileFor(UserFileDO userFileDO) {
        Map<String,Object> map = new HashMap<String, Object>();
        map.put("id",userFileDO.getId());
        return userFileDao.listFileFor(map);
    }

    @Override
    public R uploadFileFor(FileDO fileDO, MultipartFile[] files, UserFileDO userFileDO) throws Exception {
        if(files != null && files.length > 0) {
            //循环获取file数组中得文件
            for (int i = 0; i < files.length; i++) {
                MultipartFile file = files[i];
                //获取文件名称(包含后缀名)
                String fileName2 = fileDO.getFileName();
                // 获取文件的后缀名
                String fileType2 = fileName2.substring(fileName2.lastIndexOf("."));
                fileType2 = fileType2.substring(1,fileType2.length());

                //文件MD5值
                String filemd5 = fileDO.getFilemd5();
                /*try{
                    filemd5 = MD5Utils.encrypt(actualPath2);
                }catch (Exception e) {
                    //异常表示文件之前没有上传
                    filemd5 = "-1";
                }*/
                //根据文件MD5值判断文件是否已经上传,如果已经上传，则不需要进行文件流上传，只需要保存到user_file表中
                Map<String,Object> map1 = new HashMap<String, Object>();
                map1.put("filemd5",filemd5);
                FileInfoDO fileInfoDO1 = fileInfoDao.getFileInfoDetail(map1);

                //获取文件保存根目录地址
                SetDO setDO = setDao.get("diskSave");
                if(null == setDO) {
                    return R.error(1,"请设置磁盘文件保存根目录");
                }
                String rootPath = setDO.getSetValue();
                //获取上级目录地址
                Map<String,Object> map = new HashMap<String, Object>();
                map.put("userid",userFileDO.getUserid());
                if(null != userFileDO.getBelong()) {
                    map.put("belong",userFileDO.getBelong());
                }else {
                    map.put("belong",-1);
                }
                UserFileDO userFileDO1 = userFileDao.getUserFileDetail(map);
                //虚拟上传目录
                String uploadPath = "";
                if(null != userFileDO1 && StringUtils.isNotEmpty(userFileDO1.getVirtualfilepath())) {
                    uploadPath = userFileDO1.getVirtualfilepath();
                }else {
                    uploadPath = rootPath + File.separator + userFileDO.getUsername();
                }
                //实际文件存储路径
                String actualPath2 = rootPath;
                // 将获取到的附件file,transferTo写入到指定的位置(即:创建dest时，指定的路径)
                String filePath2 = uploadPath + File.separator +fileName2;
                actualPath2 = actualPath2 + File.separator +fileName2;

                if(null == fileInfoDO1) {
                    //表示文件之前没有上传，需要分块上传
                    //文件分块上传
                    String actualPath1 = "";
                    String filePath = "";
                    try  {
                        String fileName = fileDO.getFileName().substring(0, fileDO.getFileName().lastIndexOf("."));
                        //文件所属文件夹路径（文件分块所在的文件夹）
                        filePath = rootPath + File.separator + fileName;
                        //文件路径（分块文件的文件保存地址）
                        String actualPath = rootPath + File.separator + fileName + File.separator + fileDO.getFileName();
                        actualPath1 = actualPath;

                        actualPath = actualPath + "_" + fileDO.getChunk();
                        File floder = new File(filePath);
                        if (!floder.exists()) {
                            try {
                                floder.mkdirs();
                            } catch (Exception e) {
                                e.printStackTrace();
                            }
                        }
                        //file.transferTo(new File(actualPath));
                        //获得文件上传的流
                        InputStream inputStream = file.getInputStream();
                        //创建一个文件输出流
                        FileOutputStream fos = new FileOutputStream(actualPath);
                        //创建一个缓冲区
                        byte[] buffer = new byte[1024 * 1024];
                        //判断是否读取完毕
                        int len = 0;
                        //如果大于0说明还存在数据;
                        while ((len = inputStream.read(buffer)) > 0) {
                            fos.write(buffer, 0, len);
                            fos.flush();
                        }

                        //关闭流
                        fos.close();
                        inputStream.close();

                    }  catch  (FileNotFoundException e) {
                        e.printStackTrace();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    // 在上传的最后片段时，将每一段合并起来
                    if (fileDO.getIsLastChunk() == 1) {

                        //保存到文件基础表数据库
                        FileInfoDO fileInfoDO = new FileInfoDO();
                        fileInfoDO.setUuid(UuidUtils.getUUID());
                        fileInfoDO.setFilename(fileName2.substring(0, fileName2.lastIndexOf(".")));
                        fileInfoDO.setFiletype(fileType2);
                        fileInfoDO.setFilesize(fileDO.getTotalSize());
                        fileInfoDO.setAddtime(new Date());
                        //是否成功发送到对方(0.否  1.是)
                        fileInfoDO.setStatus("1");
                        //文件md5值
                        fileInfoDO.setFilemd5(filemd5);
                        fileInfoDao.save(fileInfoDO);

                        userFileDO.setFileuuid(fileInfoDO.getUuid());
                        //保存记录到user_file表中
                        //ip地址
                        // 获取request
                        HttpServletRequest request = HttpContextUtils.getHttpServletRequest();
                        userFileDO.setIp(IPUtils.getIpAddr(request));
                        userFileDO.setFilename(fileName2.substring(0, fileName2.lastIndexOf(".")));
                        userFileDO.setFiletype(fileType2);
                        //是否目录（0.否   1.是）
                        userFileDO.setIsFolder(0);
                        //状态（-1：类型检查，-2：病毒扫描，-3：加密失败，0：上传成功）
                        userFileDO.setStatus(0);
                        userFileDO.setVirtualfilepath(filePath2);
                        userFileDO.setAddtime(new Date());
                        //是否是接收文件（0:否，1：是）
                        userFileDO.setIsreceive(0);
                        userFileDao.save(userFileDO);

                        //文件上传定时器写文件
                        String encryPath = rootPath + File.separator + "ENCRY_" + userFileDO.getFileuuid() + fileName2;
                        writeFile(rootPath,fileDO,filePath,actualPath1,actualPath2,encryPath,file,userFileDO,fileInfoDO);

                    }
                }else {
                    //文件存在的时候，直接保存一次，返回一个标识，提示不需要分片上传
                    userFileDO.setFileuuid(fileInfoDO1.getUuid());
                    //保存记录到user_file表中
                    //ip地址
                    // 获取request
                    HttpServletRequest request = HttpContextUtils.getHttpServletRequest();
                    userFileDO.setIp(IPUtils.getIpAddr(request));
                    userFileDO.setFilename(fileName2.substring(0, fileName2.lastIndexOf(".")));
                    userFileDO.setFiletype(fileType2);
                    //是否目录（0.否   1.是）
                    userFileDO.setIsFolder(0);
                    //状态（-1：类型检查，-2：病毒扫描，-3：加密失败，0：上传成功）
                    userFileDO.setStatus(0);
                    userFileDO.setVirtualfilepath(filePath2);
                    userFileDO.setAddtime(new Date());
                    //是否是接收文件（0:否，1：是）
                    userFileDO.setIsreceive(0);
                    userFileDao.save(userFileDO);
                    R r = new R();
                    r.put("code", 2);
                    return r;
                }
            }
        }
        return R.ok();
    }

    /**
     * 文件上传定时器写文件
     * @return
     */
    private void writeFile(String rootPath, FileDO fileDO, String filePath, String actualPath1, String actualPath2, String encryPath, MultipartFile file, UserFileDO userFileDO, FileInfoDO fileInfoDO) throws Exception {
        //同步服务器访问地址
        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            public void run() {
                //分块全部上传完毕,合并
                File newFile = new File(rootPath, fileDO.getFileName());
                FileOutputStream outputStream = null;//文件追加写入
                try {
                    outputStream = new FileOutputStream(newFile, true);
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                }
                byte[] byt = new byte[10 * 1024 * 1024];
                int len = 0;
                FileInputStream temp = null;//分片文件
                for (int k = 0; k < fileDO.getChunks(); k++) {
                    try {
                        temp = new FileInputStream(new File(actualPath1 + "_" + k));
                    } catch (FileNotFoundException e) {
                        e.printStackTrace();
                    }
                    while (true) {
                        try {
                            if (!((len = temp.read(byt)) != -1)) break;
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                        try {
                            outputStream.write(byt, 0, len);
                            outputStream.flush();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
                //关闭流
                try {
                    temp.close();
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                /** 0:文件已经正常上传
                 * -1：文件类型错误
                 *  1：文件正在进行类型检查
                 * -2：文件存在病毒
                 *  2：文件正在杀毒
                 * -3：文件加密失败
                 *  3：文件正在进行加密*/
                int count = 0;
                try {
                    count = UploadFile.uploadFile(new File(actualPath2),userFileDO.getFileuuid());
                } catch (Exception e) {
                    e.printStackTrace();
                }

                //java定时器（文件上传成功之后30s同步到另一台服务器）
                /*if(count == 0) {
                    //加密成功才可以同步文件
                    try {
                        synchroServer(rootPath,encryPath,file.getOriginalFilename(),fileInfoDO);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }*/

                //修改文件上传状态
                userFileDO.setStatus(count);
                userFileDao.update(userFileDO);

                if(count != -2) {
                    //文件上传成功
                    //往baidujiex.file_info表中插入一条记录
                    //获取同步服务器ip地址
                    DriverManagerDataSource dataSource=new DriverManagerDataSource();
                    dataSource.setDriverClassName("com.mysql.jdbc.Driver");
                    dataSource.setUrl("jdbc:mysql://" + bootdoConfig.getLocalDataBaseIp() + ":" + bootdoConfig.getRemoteDataBasePort() + "/baidujiex?useUnicode=true&characterEncoding=utf8");
                    dataSource.setUsername(bootdoConfig.getRemoteDataBaseUser());
                    dataSource.setPassword(bootdoConfig.getRemoteDataBasePassword());
                    JdbcTemplate jdbcTemplate=new JdbcTemplate(dataSource);
                    String sql = "insert into baidujiex.file_info(id,uuid,filename,filetype,filemd5) values(null,?,?,?,?)";
                    KeyHolder keyHolder = new GeneratedKeyHolder();
                    jdbcTemplate.update(new PreparedStatementCreator() {
                        @Override
                        public PreparedStatement createPreparedStatement(Connection connection) throws SQLException {
                            PreparedStatement ps = connection.prepareStatement(sql,new String[]{"id"});
                            ps.setString(1,fileInfoDO.getUuid());
                            ps.setString(2,fileInfoDO.getFilename());
                            ps.setString(3,fileInfoDO.getFiletype());
                            ps.setString(4,fileInfoDO.getFilemd5());
                            return ps;
                        }
                    },keyHolder);

                }

                System.gc();
                System.runFinalization();
                System.gc();
                if(count == -2) {
                    //文件存在病毒，需要删除磁盘之后的病毒文件
                    File file1 = new File(actualPath2);
                    file1.delete();

                    //删除文件基础表病毒数据
                    fileInfoDao.remove(fileInfoDO.getId());
                }

                //删除分段文件及总文件夹
                deleteDir(filePath);
                deleteDir(filePath);
                //删除目标文件
                String path = filePath + "." + userFileDO.getFiletype();
                File file = new File(path);
                file.delete();

                timer.cancel();
            }
        }, 2000, 2000);
    }

    /**
     * 文件取消上传
     * @param fileDO
     * @return
     */
    @Override
    public R cancelUploadFile(FileDO fileDO) {
        //删除分段文件及总文件夹
        //获取文件保存根目录地址
        SetDO setDO = setDao.get("diskSave");
        if(null == setDO) {
            return R.error(1,"请设置磁盘文件保存根目录");
        }
        String rootPath = setDO.getSetValue();
        if(StringUtils.isNotEmpty(fileDO.getFileNames())) {
            String[] fileNameList = fileDO.getFileNames().split(",");
            for(String fileName : fileNameList) {
                if(StringUtils.isNotEmpty(fileName)) {
                    //文件所属文件夹路径
                    fileName = fileName.substring(0, fileName.lastIndexOf("."));
                    String filePath = rootPath + File.separator + fileName;
                    //删除分段文件及总文件夹
                    deleteDir(filePath);
                    deleteDir(filePath);
                }
            }
        }
        return R.ok();
    }

    /**
     * 迭代删除文件夹
     * @param dirPath 文件夹路径
     */
    public static void deleteDir(String dirPath) {
        File file = new File(dirPath);
        System.gc();
        if(file.isFile()) {
            file.delete();
        }else  {
            File[] files = file.listFiles();
            if(files == null) {
                file.delete();
            }else {
                for (int i = 0; i < files.length; i++) {
                    deleteDir(files[i].getAbsolutePath());
                }
                file.delete();
            }
        }
    }

    @Override
    public  List<UserFileDO> getFiletypeCount(Long auditid){
      return   userFileDao.getFiletypeCount(auditid);
    }

    @Override
    public R uploadFileForAll(FileDO fileDO, MultipartFile file, UserFileDO userFileDO, String fileName2, String fileType2, String filePath2, String rootPath, String filePath, String actualPath1, String actualPath2) {
        //保存到文件基础表数据库
        FileInfoDO fileInfoDO = new FileInfoDO();
        fileInfoDO.setUuid(UuidUtils.getUUID());
        fileInfoDO.setFilename(fileName2.substring(0, fileName2.lastIndexOf(".")));
        fileInfoDO.setFiletype(fileType2);
        fileInfoDO.setFilesize(fileDO.getTotalSize());
        fileInfoDO.setAddtime(new Date());
        //是否成功发送到对方(0.否  1.是)
        fileInfoDO.setStatus("0");
        //文件md5值
        fileInfoDO.setFilemd5(fileDO.getFilemd5());
        fileInfoDao.save(fileInfoDO);

        userFileDO.setFileuuid(fileInfoDO.getUuid());
        //保存记录到user_file表中
        //ip地址
        // 获取request
        HttpServletRequest request = HttpContextUtils.getHttpServletRequest();
        userFileDO.setIp(IPUtils.getIpAddr(request));
        userFileDO.setFilename(fileName2.substring(0, fileName2.lastIndexOf(".")));
        userFileDO.setFiletype(fileType2);
        //是否目录（0.否   1.是）
        userFileDO.setIsFolder(0);
        //状态（-1：类型检查，-2：病毒扫描，-3：加密失败，0：上传成功）
        userFileDO.setStatus(0);
        userFileDO.setVirtualfilepath(filePath2);
        userFileDO.setAddtime(new Date());
        //是否是接收文件（0:否，1：是）
        userFileDO.setIsreceive(0);
        userFileDao.save(userFileDO);

        //文件上传定时器写文件
        try {
            writeFile(rootPath,fileDO,filePath,actualPath1,actualPath2,actualPath2,file,userFileDO,fileInfoDO);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return R.ok();
    }
}
